/*
 * XML Type:  InvestmentTransactionList
 * Namespace: http://ofx.net/types/2003/04
 * Java type: net.ofx.types.x2003.x04.InvestmentTransactionList
 *
 * Automatically generated - do not modify.
 */
package net.ofx.types.x2003.x04.impl;
/**
 * An XML InvestmentTransactionList(@http://ofx.net/types/2003/04).
 *
 * This is a complex type.
 */
public class InvestmentTransactionListImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.ofx.types.x2003.x04.InvestmentTransactionList
{
    
    public InvestmentTransactionListImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName DTSTART$0 = 
        new javax.xml.namespace.QName("", "DTSTART");
    private static final javax.xml.namespace.QName DTEND$2 = 
        new javax.xml.namespace.QName("", "DTEND");
    private static final javax.xml.namespace.QName BUYDEBT$4 = 
        new javax.xml.namespace.QName("", "BUYDEBT");
    private static final javax.xml.namespace.QName BUYMF$6 = 
        new javax.xml.namespace.QName("", "BUYMF");
    private static final javax.xml.namespace.QName BUYOPT$8 = 
        new javax.xml.namespace.QName("", "BUYOPT");
    private static final javax.xml.namespace.QName BUYOTHER$10 = 
        new javax.xml.namespace.QName("", "BUYOTHER");
    private static final javax.xml.namespace.QName BUYSTOCK$12 = 
        new javax.xml.namespace.QName("", "BUYSTOCK");
    private static final javax.xml.namespace.QName CLOSUREOPT$14 = 
        new javax.xml.namespace.QName("", "CLOSUREOPT");
    private static final javax.xml.namespace.QName INCOME$16 = 
        new javax.xml.namespace.QName("", "INCOME");
    private static final javax.xml.namespace.QName INVEXPENSE$18 = 
        new javax.xml.namespace.QName("", "INVEXPENSE");
    private static final javax.xml.namespace.QName JRNLFUND$20 = 
        new javax.xml.namespace.QName("", "JRNLFUND");
    private static final javax.xml.namespace.QName JRNLSEC$22 = 
        new javax.xml.namespace.QName("", "JRNLSEC");
    private static final javax.xml.namespace.QName MARGININTEREST$24 = 
        new javax.xml.namespace.QName("", "MARGININTEREST");
    private static final javax.xml.namespace.QName REINVEST$26 = 
        new javax.xml.namespace.QName("", "REINVEST");
    private static final javax.xml.namespace.QName RETOFCAP$28 = 
        new javax.xml.namespace.QName("", "RETOFCAP");
    private static final javax.xml.namespace.QName SELLDEBT$30 = 
        new javax.xml.namespace.QName("", "SELLDEBT");
    private static final javax.xml.namespace.QName SELLMF$32 = 
        new javax.xml.namespace.QName("", "SELLMF");
    private static final javax.xml.namespace.QName SELLOPT$34 = 
        new javax.xml.namespace.QName("", "SELLOPT");
    private static final javax.xml.namespace.QName SELLOTHER$36 = 
        new javax.xml.namespace.QName("", "SELLOTHER");
    private static final javax.xml.namespace.QName SELLSTOCK$38 = 
        new javax.xml.namespace.QName("", "SELLSTOCK");
    private static final javax.xml.namespace.QName SPLIT$40 = 
        new javax.xml.namespace.QName("", "SPLIT");
    private static final javax.xml.namespace.QName TRANSFER$42 = 
        new javax.xml.namespace.QName("", "TRANSFER");
    private static final javax.xml.namespace.QName INVBANKTRAN$44 = 
        new javax.xml.namespace.QName("", "INVBANKTRAN");
    
    
    /**
     * Gets the "DTSTART" element
     */
    public java.lang.String getDTSTART()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(DTSTART$0, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "DTSTART" element
     */
    public net.ofx.types.x2003.x04.DateTimeType xgetDTSTART()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.DateTimeType target = null;
            target = (net.ofx.types.x2003.x04.DateTimeType)get_store().find_element_user(DTSTART$0, 0);
            return target;
        }
    }
    
    /**
     * Sets the "DTSTART" element
     */
    public void setDTSTART(java.lang.String dtstart)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(DTSTART$0, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(DTSTART$0);
            }
            target.setStringValue(dtstart);
        }
    }
    
    /**
     * Sets (as xml) the "DTSTART" element
     */
    public void xsetDTSTART(net.ofx.types.x2003.x04.DateTimeType dtstart)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.DateTimeType target = null;
            target = (net.ofx.types.x2003.x04.DateTimeType)get_store().find_element_user(DTSTART$0, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.DateTimeType)get_store().add_element_user(DTSTART$0);
            }
            target.set(dtstart);
        }
    }
    
    /**
     * Gets the "DTEND" element
     */
    public java.lang.String getDTEND()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(DTEND$2, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "DTEND" element
     */
    public net.ofx.types.x2003.x04.DateTimeType xgetDTEND()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.DateTimeType target = null;
            target = (net.ofx.types.x2003.x04.DateTimeType)get_store().find_element_user(DTEND$2, 0);
            return target;
        }
    }
    
    /**
     * Sets the "DTEND" element
     */
    public void setDTEND(java.lang.String dtend)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(DTEND$2, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(DTEND$2);
            }
            target.setStringValue(dtend);
        }
    }
    
    /**
     * Sets (as xml) the "DTEND" element
     */
    public void xsetDTEND(net.ofx.types.x2003.x04.DateTimeType dtend)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.DateTimeType target = null;
            target = (net.ofx.types.x2003.x04.DateTimeType)get_store().find_element_user(DTEND$2, 0);
            if (target == null)
            {
                target = (net.ofx.types.x2003.x04.DateTimeType)get_store().add_element_user(DTEND$2);
            }
            target.set(dtend);
        }
    }
    
    /**
     * Gets array of all "BUYDEBT" elements
     */
    public net.ofx.types.x2003.x04.BuyDebt[] getBUYDEBTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BUYDEBT$4, targetList);
            net.ofx.types.x2003.x04.BuyDebt[] result = new net.ofx.types.x2003.x04.BuyDebt[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "BUYDEBT" element
     */
    public net.ofx.types.x2003.x04.BuyDebt getBUYDEBTArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyDebt target = null;
            target = (net.ofx.types.x2003.x04.BuyDebt)get_store().find_element_user(BUYDEBT$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "BUYDEBT" element
     */
    public int sizeOfBUYDEBTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BUYDEBT$4);
        }
    }
    
    /**
     * Sets array of all "BUYDEBT" element
     */
    public void setBUYDEBTArray(net.ofx.types.x2003.x04.BuyDebt[] buydebtArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(buydebtArray, BUYDEBT$4);
        }
    }
    
    /**
     * Sets ith "BUYDEBT" element
     */
    public void setBUYDEBTArray(int i, net.ofx.types.x2003.x04.BuyDebt buydebt)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyDebt target = null;
            target = (net.ofx.types.x2003.x04.BuyDebt)get_store().find_element_user(BUYDEBT$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(buydebt);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "BUYDEBT" element
     */
    public net.ofx.types.x2003.x04.BuyDebt insertNewBUYDEBT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyDebt target = null;
            target = (net.ofx.types.x2003.x04.BuyDebt)get_store().insert_element_user(BUYDEBT$4, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "BUYDEBT" element
     */
    public net.ofx.types.x2003.x04.BuyDebt addNewBUYDEBT()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyDebt target = null;
            target = (net.ofx.types.x2003.x04.BuyDebt)get_store().add_element_user(BUYDEBT$4);
            return target;
        }
    }
    
    /**
     * Removes the ith "BUYDEBT" element
     */
    public void removeBUYDEBT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BUYDEBT$4, i);
        }
    }
    
    /**
     * Gets array of all "BUYMF" elements
     */
    public net.ofx.types.x2003.x04.BuyMutualFund[] getBUYMFArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BUYMF$6, targetList);
            net.ofx.types.x2003.x04.BuyMutualFund[] result = new net.ofx.types.x2003.x04.BuyMutualFund[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "BUYMF" element
     */
    public net.ofx.types.x2003.x04.BuyMutualFund getBUYMFArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyMutualFund target = null;
            target = (net.ofx.types.x2003.x04.BuyMutualFund)get_store().find_element_user(BUYMF$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "BUYMF" element
     */
    public int sizeOfBUYMFArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BUYMF$6);
        }
    }
    
    /**
     * Sets array of all "BUYMF" element
     */
    public void setBUYMFArray(net.ofx.types.x2003.x04.BuyMutualFund[] buymfArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(buymfArray, BUYMF$6);
        }
    }
    
    /**
     * Sets ith "BUYMF" element
     */
    public void setBUYMFArray(int i, net.ofx.types.x2003.x04.BuyMutualFund buymf)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyMutualFund target = null;
            target = (net.ofx.types.x2003.x04.BuyMutualFund)get_store().find_element_user(BUYMF$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(buymf);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "BUYMF" element
     */
    public net.ofx.types.x2003.x04.BuyMutualFund insertNewBUYMF(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyMutualFund target = null;
            target = (net.ofx.types.x2003.x04.BuyMutualFund)get_store().insert_element_user(BUYMF$6, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "BUYMF" element
     */
    public net.ofx.types.x2003.x04.BuyMutualFund addNewBUYMF()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyMutualFund target = null;
            target = (net.ofx.types.x2003.x04.BuyMutualFund)get_store().add_element_user(BUYMF$6);
            return target;
        }
    }
    
    /**
     * Removes the ith "BUYMF" element
     */
    public void removeBUYMF(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BUYMF$6, i);
        }
    }
    
    /**
     * Gets array of all "BUYOPT" elements
     */
    public net.ofx.types.x2003.x04.BuyOption[] getBUYOPTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BUYOPT$8, targetList);
            net.ofx.types.x2003.x04.BuyOption[] result = new net.ofx.types.x2003.x04.BuyOption[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "BUYOPT" element
     */
    public net.ofx.types.x2003.x04.BuyOption getBUYOPTArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyOption target = null;
            target = (net.ofx.types.x2003.x04.BuyOption)get_store().find_element_user(BUYOPT$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "BUYOPT" element
     */
    public int sizeOfBUYOPTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BUYOPT$8);
        }
    }
    
    /**
     * Sets array of all "BUYOPT" element
     */
    public void setBUYOPTArray(net.ofx.types.x2003.x04.BuyOption[] buyoptArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(buyoptArray, BUYOPT$8);
        }
    }
    
    /**
     * Sets ith "BUYOPT" element
     */
    public void setBUYOPTArray(int i, net.ofx.types.x2003.x04.BuyOption buyopt)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyOption target = null;
            target = (net.ofx.types.x2003.x04.BuyOption)get_store().find_element_user(BUYOPT$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(buyopt);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "BUYOPT" element
     */
    public net.ofx.types.x2003.x04.BuyOption insertNewBUYOPT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyOption target = null;
            target = (net.ofx.types.x2003.x04.BuyOption)get_store().insert_element_user(BUYOPT$8, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "BUYOPT" element
     */
    public net.ofx.types.x2003.x04.BuyOption addNewBUYOPT()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyOption target = null;
            target = (net.ofx.types.x2003.x04.BuyOption)get_store().add_element_user(BUYOPT$8);
            return target;
        }
    }
    
    /**
     * Removes the ith "BUYOPT" element
     */
    public void removeBUYOPT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BUYOPT$8, i);
        }
    }
    
    /**
     * Gets array of all "BUYOTHER" elements
     */
    public net.ofx.types.x2003.x04.BuyOther[] getBUYOTHERArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BUYOTHER$10, targetList);
            net.ofx.types.x2003.x04.BuyOther[] result = new net.ofx.types.x2003.x04.BuyOther[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "BUYOTHER" element
     */
    public net.ofx.types.x2003.x04.BuyOther getBUYOTHERArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyOther target = null;
            target = (net.ofx.types.x2003.x04.BuyOther)get_store().find_element_user(BUYOTHER$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "BUYOTHER" element
     */
    public int sizeOfBUYOTHERArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BUYOTHER$10);
        }
    }
    
    /**
     * Sets array of all "BUYOTHER" element
     */
    public void setBUYOTHERArray(net.ofx.types.x2003.x04.BuyOther[] buyotherArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(buyotherArray, BUYOTHER$10);
        }
    }
    
    /**
     * Sets ith "BUYOTHER" element
     */
    public void setBUYOTHERArray(int i, net.ofx.types.x2003.x04.BuyOther buyother)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyOther target = null;
            target = (net.ofx.types.x2003.x04.BuyOther)get_store().find_element_user(BUYOTHER$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(buyother);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "BUYOTHER" element
     */
    public net.ofx.types.x2003.x04.BuyOther insertNewBUYOTHER(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyOther target = null;
            target = (net.ofx.types.x2003.x04.BuyOther)get_store().insert_element_user(BUYOTHER$10, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "BUYOTHER" element
     */
    public net.ofx.types.x2003.x04.BuyOther addNewBUYOTHER()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyOther target = null;
            target = (net.ofx.types.x2003.x04.BuyOther)get_store().add_element_user(BUYOTHER$10);
            return target;
        }
    }
    
    /**
     * Removes the ith "BUYOTHER" element
     */
    public void removeBUYOTHER(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BUYOTHER$10, i);
        }
    }
    
    /**
     * Gets array of all "BUYSTOCK" elements
     */
    public net.ofx.types.x2003.x04.BuyStock[] getBUYSTOCKArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BUYSTOCK$12, targetList);
            net.ofx.types.x2003.x04.BuyStock[] result = new net.ofx.types.x2003.x04.BuyStock[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "BUYSTOCK" element
     */
    public net.ofx.types.x2003.x04.BuyStock getBUYSTOCKArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyStock target = null;
            target = (net.ofx.types.x2003.x04.BuyStock)get_store().find_element_user(BUYSTOCK$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "BUYSTOCK" element
     */
    public int sizeOfBUYSTOCKArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BUYSTOCK$12);
        }
    }
    
    /**
     * Sets array of all "BUYSTOCK" element
     */
    public void setBUYSTOCKArray(net.ofx.types.x2003.x04.BuyStock[] buystockArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(buystockArray, BUYSTOCK$12);
        }
    }
    
    /**
     * Sets ith "BUYSTOCK" element
     */
    public void setBUYSTOCKArray(int i, net.ofx.types.x2003.x04.BuyStock buystock)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyStock target = null;
            target = (net.ofx.types.x2003.x04.BuyStock)get_store().find_element_user(BUYSTOCK$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(buystock);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "BUYSTOCK" element
     */
    public net.ofx.types.x2003.x04.BuyStock insertNewBUYSTOCK(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyStock target = null;
            target = (net.ofx.types.x2003.x04.BuyStock)get_store().insert_element_user(BUYSTOCK$12, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "BUYSTOCK" element
     */
    public net.ofx.types.x2003.x04.BuyStock addNewBUYSTOCK()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BuyStock target = null;
            target = (net.ofx.types.x2003.x04.BuyStock)get_store().add_element_user(BUYSTOCK$12);
            return target;
        }
    }
    
    /**
     * Removes the ith "BUYSTOCK" element
     */
    public void removeBUYSTOCK(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BUYSTOCK$12, i);
        }
    }
    
    /**
     * Gets array of all "CLOSUREOPT" elements
     */
    public net.ofx.types.x2003.x04.ClosureOption[] getCLOSUREOPTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CLOSUREOPT$14, targetList);
            net.ofx.types.x2003.x04.ClosureOption[] result = new net.ofx.types.x2003.x04.ClosureOption[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "CLOSUREOPT" element
     */
    public net.ofx.types.x2003.x04.ClosureOption getCLOSUREOPTArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ClosureOption target = null;
            target = (net.ofx.types.x2003.x04.ClosureOption)get_store().find_element_user(CLOSUREOPT$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "CLOSUREOPT" element
     */
    public int sizeOfCLOSUREOPTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CLOSUREOPT$14);
        }
    }
    
    /**
     * Sets array of all "CLOSUREOPT" element
     */
    public void setCLOSUREOPTArray(net.ofx.types.x2003.x04.ClosureOption[] closureoptArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(closureoptArray, CLOSUREOPT$14);
        }
    }
    
    /**
     * Sets ith "CLOSUREOPT" element
     */
    public void setCLOSUREOPTArray(int i, net.ofx.types.x2003.x04.ClosureOption closureopt)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ClosureOption target = null;
            target = (net.ofx.types.x2003.x04.ClosureOption)get_store().find_element_user(CLOSUREOPT$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(closureopt);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "CLOSUREOPT" element
     */
    public net.ofx.types.x2003.x04.ClosureOption insertNewCLOSUREOPT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ClosureOption target = null;
            target = (net.ofx.types.x2003.x04.ClosureOption)get_store().insert_element_user(CLOSUREOPT$14, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "CLOSUREOPT" element
     */
    public net.ofx.types.x2003.x04.ClosureOption addNewCLOSUREOPT()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ClosureOption target = null;
            target = (net.ofx.types.x2003.x04.ClosureOption)get_store().add_element_user(CLOSUREOPT$14);
            return target;
        }
    }
    
    /**
     * Removes the ith "CLOSUREOPT" element
     */
    public void removeCLOSUREOPT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CLOSUREOPT$14, i);
        }
    }
    
    /**
     * Gets array of all "INCOME" elements
     */
    public net.ofx.types.x2003.x04.Income[] getINCOMEArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(INCOME$16, targetList);
            net.ofx.types.x2003.x04.Income[] result = new net.ofx.types.x2003.x04.Income[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "INCOME" element
     */
    public net.ofx.types.x2003.x04.Income getINCOMEArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Income target = null;
            target = (net.ofx.types.x2003.x04.Income)get_store().find_element_user(INCOME$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "INCOME" element
     */
    public int sizeOfINCOMEArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INCOME$16);
        }
    }
    
    /**
     * Sets array of all "INCOME" element
     */
    public void setINCOMEArray(net.ofx.types.x2003.x04.Income[] incomeArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(incomeArray, INCOME$16);
        }
    }
    
    /**
     * Sets ith "INCOME" element
     */
    public void setINCOMEArray(int i, net.ofx.types.x2003.x04.Income income)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Income target = null;
            target = (net.ofx.types.x2003.x04.Income)get_store().find_element_user(INCOME$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(income);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "INCOME" element
     */
    public net.ofx.types.x2003.x04.Income insertNewINCOME(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Income target = null;
            target = (net.ofx.types.x2003.x04.Income)get_store().insert_element_user(INCOME$16, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "INCOME" element
     */
    public net.ofx.types.x2003.x04.Income addNewINCOME()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Income target = null;
            target = (net.ofx.types.x2003.x04.Income)get_store().add_element_user(INCOME$16);
            return target;
        }
    }
    
    /**
     * Removes the ith "INCOME" element
     */
    public void removeINCOME(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INCOME$16, i);
        }
    }
    
    /**
     * Gets array of all "INVEXPENSE" elements
     */
    public net.ofx.types.x2003.x04.InvestmentExpense[] getINVEXPENSEArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(INVEXPENSE$18, targetList);
            net.ofx.types.x2003.x04.InvestmentExpense[] result = new net.ofx.types.x2003.x04.InvestmentExpense[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "INVEXPENSE" element
     */
    public net.ofx.types.x2003.x04.InvestmentExpense getINVEXPENSEArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentExpense target = null;
            target = (net.ofx.types.x2003.x04.InvestmentExpense)get_store().find_element_user(INVEXPENSE$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "INVEXPENSE" element
     */
    public int sizeOfINVEXPENSEArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INVEXPENSE$18);
        }
    }
    
    /**
     * Sets array of all "INVEXPENSE" element
     */
    public void setINVEXPENSEArray(net.ofx.types.x2003.x04.InvestmentExpense[] invexpenseArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(invexpenseArray, INVEXPENSE$18);
        }
    }
    
    /**
     * Sets ith "INVEXPENSE" element
     */
    public void setINVEXPENSEArray(int i, net.ofx.types.x2003.x04.InvestmentExpense invexpense)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentExpense target = null;
            target = (net.ofx.types.x2003.x04.InvestmentExpense)get_store().find_element_user(INVEXPENSE$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(invexpense);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "INVEXPENSE" element
     */
    public net.ofx.types.x2003.x04.InvestmentExpense insertNewINVEXPENSE(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentExpense target = null;
            target = (net.ofx.types.x2003.x04.InvestmentExpense)get_store().insert_element_user(INVEXPENSE$18, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "INVEXPENSE" element
     */
    public net.ofx.types.x2003.x04.InvestmentExpense addNewINVEXPENSE()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentExpense target = null;
            target = (net.ofx.types.x2003.x04.InvestmentExpense)get_store().add_element_user(INVEXPENSE$18);
            return target;
        }
    }
    
    /**
     * Removes the ith "INVEXPENSE" element
     */
    public void removeINVEXPENSE(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INVEXPENSE$18, i);
        }
    }
    
    /**
     * Gets array of all "JRNLFUND" elements
     */
    public net.ofx.types.x2003.x04.JournalFund[] getJRNLFUNDArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(JRNLFUND$20, targetList);
            net.ofx.types.x2003.x04.JournalFund[] result = new net.ofx.types.x2003.x04.JournalFund[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "JRNLFUND" element
     */
    public net.ofx.types.x2003.x04.JournalFund getJRNLFUNDArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.JournalFund target = null;
            target = (net.ofx.types.x2003.x04.JournalFund)get_store().find_element_user(JRNLFUND$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "JRNLFUND" element
     */
    public int sizeOfJRNLFUNDArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(JRNLFUND$20);
        }
    }
    
    /**
     * Sets array of all "JRNLFUND" element
     */
    public void setJRNLFUNDArray(net.ofx.types.x2003.x04.JournalFund[] jrnlfundArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(jrnlfundArray, JRNLFUND$20);
        }
    }
    
    /**
     * Sets ith "JRNLFUND" element
     */
    public void setJRNLFUNDArray(int i, net.ofx.types.x2003.x04.JournalFund jrnlfund)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.JournalFund target = null;
            target = (net.ofx.types.x2003.x04.JournalFund)get_store().find_element_user(JRNLFUND$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(jrnlfund);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "JRNLFUND" element
     */
    public net.ofx.types.x2003.x04.JournalFund insertNewJRNLFUND(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.JournalFund target = null;
            target = (net.ofx.types.x2003.x04.JournalFund)get_store().insert_element_user(JRNLFUND$20, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "JRNLFUND" element
     */
    public net.ofx.types.x2003.x04.JournalFund addNewJRNLFUND()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.JournalFund target = null;
            target = (net.ofx.types.x2003.x04.JournalFund)get_store().add_element_user(JRNLFUND$20);
            return target;
        }
    }
    
    /**
     * Removes the ith "JRNLFUND" element
     */
    public void removeJRNLFUND(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(JRNLFUND$20, i);
        }
    }
    
    /**
     * Gets array of all "JRNLSEC" elements
     */
    public net.ofx.types.x2003.x04.JournalSecurity[] getJRNLSECArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(JRNLSEC$22, targetList);
            net.ofx.types.x2003.x04.JournalSecurity[] result = new net.ofx.types.x2003.x04.JournalSecurity[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "JRNLSEC" element
     */
    public net.ofx.types.x2003.x04.JournalSecurity getJRNLSECArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.JournalSecurity target = null;
            target = (net.ofx.types.x2003.x04.JournalSecurity)get_store().find_element_user(JRNLSEC$22, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "JRNLSEC" element
     */
    public int sizeOfJRNLSECArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(JRNLSEC$22);
        }
    }
    
    /**
     * Sets array of all "JRNLSEC" element
     */
    public void setJRNLSECArray(net.ofx.types.x2003.x04.JournalSecurity[] jrnlsecArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(jrnlsecArray, JRNLSEC$22);
        }
    }
    
    /**
     * Sets ith "JRNLSEC" element
     */
    public void setJRNLSECArray(int i, net.ofx.types.x2003.x04.JournalSecurity jrnlsec)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.JournalSecurity target = null;
            target = (net.ofx.types.x2003.x04.JournalSecurity)get_store().find_element_user(JRNLSEC$22, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(jrnlsec);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "JRNLSEC" element
     */
    public net.ofx.types.x2003.x04.JournalSecurity insertNewJRNLSEC(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.JournalSecurity target = null;
            target = (net.ofx.types.x2003.x04.JournalSecurity)get_store().insert_element_user(JRNLSEC$22, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "JRNLSEC" element
     */
    public net.ofx.types.x2003.x04.JournalSecurity addNewJRNLSEC()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.JournalSecurity target = null;
            target = (net.ofx.types.x2003.x04.JournalSecurity)get_store().add_element_user(JRNLSEC$22);
            return target;
        }
    }
    
    /**
     * Removes the ith "JRNLSEC" element
     */
    public void removeJRNLSEC(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(JRNLSEC$22, i);
        }
    }
    
    /**
     * Gets array of all "MARGININTEREST" elements
     */
    public net.ofx.types.x2003.x04.MarginInterest[] getMARGININTERESTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(MARGININTEREST$24, targetList);
            net.ofx.types.x2003.x04.MarginInterest[] result = new net.ofx.types.x2003.x04.MarginInterest[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "MARGININTEREST" element
     */
    public net.ofx.types.x2003.x04.MarginInterest getMARGININTERESTArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.MarginInterest target = null;
            target = (net.ofx.types.x2003.x04.MarginInterest)get_store().find_element_user(MARGININTEREST$24, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "MARGININTEREST" element
     */
    public int sizeOfMARGININTERESTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(MARGININTEREST$24);
        }
    }
    
    /**
     * Sets array of all "MARGININTEREST" element
     */
    public void setMARGININTERESTArray(net.ofx.types.x2003.x04.MarginInterest[] margininterestArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(margininterestArray, MARGININTEREST$24);
        }
    }
    
    /**
     * Sets ith "MARGININTEREST" element
     */
    public void setMARGININTERESTArray(int i, net.ofx.types.x2003.x04.MarginInterest margininterest)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.MarginInterest target = null;
            target = (net.ofx.types.x2003.x04.MarginInterest)get_store().find_element_user(MARGININTEREST$24, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(margininterest);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "MARGININTEREST" element
     */
    public net.ofx.types.x2003.x04.MarginInterest insertNewMARGININTEREST(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.MarginInterest target = null;
            target = (net.ofx.types.x2003.x04.MarginInterest)get_store().insert_element_user(MARGININTEREST$24, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "MARGININTEREST" element
     */
    public net.ofx.types.x2003.x04.MarginInterest addNewMARGININTEREST()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.MarginInterest target = null;
            target = (net.ofx.types.x2003.x04.MarginInterest)get_store().add_element_user(MARGININTEREST$24);
            return target;
        }
    }
    
    /**
     * Removes the ith "MARGININTEREST" element
     */
    public void removeMARGININTEREST(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(MARGININTEREST$24, i);
        }
    }
    
    /**
     * Gets array of all "REINVEST" elements
     */
    public net.ofx.types.x2003.x04.Reinvest[] getREINVESTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(REINVEST$26, targetList);
            net.ofx.types.x2003.x04.Reinvest[] result = new net.ofx.types.x2003.x04.Reinvest[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "REINVEST" element
     */
    public net.ofx.types.x2003.x04.Reinvest getREINVESTArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Reinvest target = null;
            target = (net.ofx.types.x2003.x04.Reinvest)get_store().find_element_user(REINVEST$26, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "REINVEST" element
     */
    public int sizeOfREINVESTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(REINVEST$26);
        }
    }
    
    /**
     * Sets array of all "REINVEST" element
     */
    public void setREINVESTArray(net.ofx.types.x2003.x04.Reinvest[] reinvestArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(reinvestArray, REINVEST$26);
        }
    }
    
    /**
     * Sets ith "REINVEST" element
     */
    public void setREINVESTArray(int i, net.ofx.types.x2003.x04.Reinvest reinvest)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Reinvest target = null;
            target = (net.ofx.types.x2003.x04.Reinvest)get_store().find_element_user(REINVEST$26, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(reinvest);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "REINVEST" element
     */
    public net.ofx.types.x2003.x04.Reinvest insertNewREINVEST(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Reinvest target = null;
            target = (net.ofx.types.x2003.x04.Reinvest)get_store().insert_element_user(REINVEST$26, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "REINVEST" element
     */
    public net.ofx.types.x2003.x04.Reinvest addNewREINVEST()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Reinvest target = null;
            target = (net.ofx.types.x2003.x04.Reinvest)get_store().add_element_user(REINVEST$26);
            return target;
        }
    }
    
    /**
     * Removes the ith "REINVEST" element
     */
    public void removeREINVEST(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(REINVEST$26, i);
        }
    }
    
    /**
     * Gets array of all "RETOFCAP" elements
     */
    public net.ofx.types.x2003.x04.ReturnOfCapital[] getRETOFCAPArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(RETOFCAP$28, targetList);
            net.ofx.types.x2003.x04.ReturnOfCapital[] result = new net.ofx.types.x2003.x04.ReturnOfCapital[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "RETOFCAP" element
     */
    public net.ofx.types.x2003.x04.ReturnOfCapital getRETOFCAPArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ReturnOfCapital target = null;
            target = (net.ofx.types.x2003.x04.ReturnOfCapital)get_store().find_element_user(RETOFCAP$28, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "RETOFCAP" element
     */
    public int sizeOfRETOFCAPArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RETOFCAP$28);
        }
    }
    
    /**
     * Sets array of all "RETOFCAP" element
     */
    public void setRETOFCAPArray(net.ofx.types.x2003.x04.ReturnOfCapital[] retofcapArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(retofcapArray, RETOFCAP$28);
        }
    }
    
    /**
     * Sets ith "RETOFCAP" element
     */
    public void setRETOFCAPArray(int i, net.ofx.types.x2003.x04.ReturnOfCapital retofcap)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ReturnOfCapital target = null;
            target = (net.ofx.types.x2003.x04.ReturnOfCapital)get_store().find_element_user(RETOFCAP$28, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(retofcap);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "RETOFCAP" element
     */
    public net.ofx.types.x2003.x04.ReturnOfCapital insertNewRETOFCAP(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ReturnOfCapital target = null;
            target = (net.ofx.types.x2003.x04.ReturnOfCapital)get_store().insert_element_user(RETOFCAP$28, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "RETOFCAP" element
     */
    public net.ofx.types.x2003.x04.ReturnOfCapital addNewRETOFCAP()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.ReturnOfCapital target = null;
            target = (net.ofx.types.x2003.x04.ReturnOfCapital)get_store().add_element_user(RETOFCAP$28);
            return target;
        }
    }
    
    /**
     * Removes the ith "RETOFCAP" element
     */
    public void removeRETOFCAP(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RETOFCAP$28, i);
        }
    }
    
    /**
     * Gets array of all "SELLDEBT" elements
     */
    public net.ofx.types.x2003.x04.SellDebt[] getSELLDEBTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SELLDEBT$30, targetList);
            net.ofx.types.x2003.x04.SellDebt[] result = new net.ofx.types.x2003.x04.SellDebt[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "SELLDEBT" element
     */
    public net.ofx.types.x2003.x04.SellDebt getSELLDEBTArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellDebt target = null;
            target = (net.ofx.types.x2003.x04.SellDebt)get_store().find_element_user(SELLDEBT$30, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "SELLDEBT" element
     */
    public int sizeOfSELLDEBTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SELLDEBT$30);
        }
    }
    
    /**
     * Sets array of all "SELLDEBT" element
     */
    public void setSELLDEBTArray(net.ofx.types.x2003.x04.SellDebt[] selldebtArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(selldebtArray, SELLDEBT$30);
        }
    }
    
    /**
     * Sets ith "SELLDEBT" element
     */
    public void setSELLDEBTArray(int i, net.ofx.types.x2003.x04.SellDebt selldebt)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellDebt target = null;
            target = (net.ofx.types.x2003.x04.SellDebt)get_store().find_element_user(SELLDEBT$30, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(selldebt);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "SELLDEBT" element
     */
    public net.ofx.types.x2003.x04.SellDebt insertNewSELLDEBT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellDebt target = null;
            target = (net.ofx.types.x2003.x04.SellDebt)get_store().insert_element_user(SELLDEBT$30, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "SELLDEBT" element
     */
    public net.ofx.types.x2003.x04.SellDebt addNewSELLDEBT()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellDebt target = null;
            target = (net.ofx.types.x2003.x04.SellDebt)get_store().add_element_user(SELLDEBT$30);
            return target;
        }
    }
    
    /**
     * Removes the ith "SELLDEBT" element
     */
    public void removeSELLDEBT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SELLDEBT$30, i);
        }
    }
    
    /**
     * Gets array of all "SELLMF" elements
     */
    public net.ofx.types.x2003.x04.SellMutualFund[] getSELLMFArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SELLMF$32, targetList);
            net.ofx.types.x2003.x04.SellMutualFund[] result = new net.ofx.types.x2003.x04.SellMutualFund[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "SELLMF" element
     */
    public net.ofx.types.x2003.x04.SellMutualFund getSELLMFArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellMutualFund target = null;
            target = (net.ofx.types.x2003.x04.SellMutualFund)get_store().find_element_user(SELLMF$32, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "SELLMF" element
     */
    public int sizeOfSELLMFArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SELLMF$32);
        }
    }
    
    /**
     * Sets array of all "SELLMF" element
     */
    public void setSELLMFArray(net.ofx.types.x2003.x04.SellMutualFund[] sellmfArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(sellmfArray, SELLMF$32);
        }
    }
    
    /**
     * Sets ith "SELLMF" element
     */
    public void setSELLMFArray(int i, net.ofx.types.x2003.x04.SellMutualFund sellmf)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellMutualFund target = null;
            target = (net.ofx.types.x2003.x04.SellMutualFund)get_store().find_element_user(SELLMF$32, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(sellmf);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "SELLMF" element
     */
    public net.ofx.types.x2003.x04.SellMutualFund insertNewSELLMF(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellMutualFund target = null;
            target = (net.ofx.types.x2003.x04.SellMutualFund)get_store().insert_element_user(SELLMF$32, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "SELLMF" element
     */
    public net.ofx.types.x2003.x04.SellMutualFund addNewSELLMF()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellMutualFund target = null;
            target = (net.ofx.types.x2003.x04.SellMutualFund)get_store().add_element_user(SELLMF$32);
            return target;
        }
    }
    
    /**
     * Removes the ith "SELLMF" element
     */
    public void removeSELLMF(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SELLMF$32, i);
        }
    }
    
    /**
     * Gets array of all "SELLOPT" elements
     */
    public net.ofx.types.x2003.x04.SellOption[] getSELLOPTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SELLOPT$34, targetList);
            net.ofx.types.x2003.x04.SellOption[] result = new net.ofx.types.x2003.x04.SellOption[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "SELLOPT" element
     */
    public net.ofx.types.x2003.x04.SellOption getSELLOPTArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellOption target = null;
            target = (net.ofx.types.x2003.x04.SellOption)get_store().find_element_user(SELLOPT$34, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "SELLOPT" element
     */
    public int sizeOfSELLOPTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SELLOPT$34);
        }
    }
    
    /**
     * Sets array of all "SELLOPT" element
     */
    public void setSELLOPTArray(net.ofx.types.x2003.x04.SellOption[] selloptArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(selloptArray, SELLOPT$34);
        }
    }
    
    /**
     * Sets ith "SELLOPT" element
     */
    public void setSELLOPTArray(int i, net.ofx.types.x2003.x04.SellOption sellopt)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellOption target = null;
            target = (net.ofx.types.x2003.x04.SellOption)get_store().find_element_user(SELLOPT$34, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(sellopt);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "SELLOPT" element
     */
    public net.ofx.types.x2003.x04.SellOption insertNewSELLOPT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellOption target = null;
            target = (net.ofx.types.x2003.x04.SellOption)get_store().insert_element_user(SELLOPT$34, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "SELLOPT" element
     */
    public net.ofx.types.x2003.x04.SellOption addNewSELLOPT()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellOption target = null;
            target = (net.ofx.types.x2003.x04.SellOption)get_store().add_element_user(SELLOPT$34);
            return target;
        }
    }
    
    /**
     * Removes the ith "SELLOPT" element
     */
    public void removeSELLOPT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SELLOPT$34, i);
        }
    }
    
    /**
     * Gets array of all "SELLOTHER" elements
     */
    public net.ofx.types.x2003.x04.SellOther[] getSELLOTHERArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SELLOTHER$36, targetList);
            net.ofx.types.x2003.x04.SellOther[] result = new net.ofx.types.x2003.x04.SellOther[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "SELLOTHER" element
     */
    public net.ofx.types.x2003.x04.SellOther getSELLOTHERArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellOther target = null;
            target = (net.ofx.types.x2003.x04.SellOther)get_store().find_element_user(SELLOTHER$36, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "SELLOTHER" element
     */
    public int sizeOfSELLOTHERArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SELLOTHER$36);
        }
    }
    
    /**
     * Sets array of all "SELLOTHER" element
     */
    public void setSELLOTHERArray(net.ofx.types.x2003.x04.SellOther[] sellotherArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(sellotherArray, SELLOTHER$36);
        }
    }
    
    /**
     * Sets ith "SELLOTHER" element
     */
    public void setSELLOTHERArray(int i, net.ofx.types.x2003.x04.SellOther sellother)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellOther target = null;
            target = (net.ofx.types.x2003.x04.SellOther)get_store().find_element_user(SELLOTHER$36, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(sellother);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "SELLOTHER" element
     */
    public net.ofx.types.x2003.x04.SellOther insertNewSELLOTHER(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellOther target = null;
            target = (net.ofx.types.x2003.x04.SellOther)get_store().insert_element_user(SELLOTHER$36, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "SELLOTHER" element
     */
    public net.ofx.types.x2003.x04.SellOther addNewSELLOTHER()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellOther target = null;
            target = (net.ofx.types.x2003.x04.SellOther)get_store().add_element_user(SELLOTHER$36);
            return target;
        }
    }
    
    /**
     * Removes the ith "SELLOTHER" element
     */
    public void removeSELLOTHER(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SELLOTHER$36, i);
        }
    }
    
    /**
     * Gets array of all "SELLSTOCK" elements
     */
    public net.ofx.types.x2003.x04.SellStock[] getSELLSTOCKArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SELLSTOCK$38, targetList);
            net.ofx.types.x2003.x04.SellStock[] result = new net.ofx.types.x2003.x04.SellStock[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "SELLSTOCK" element
     */
    public net.ofx.types.x2003.x04.SellStock getSELLSTOCKArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellStock target = null;
            target = (net.ofx.types.x2003.x04.SellStock)get_store().find_element_user(SELLSTOCK$38, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "SELLSTOCK" element
     */
    public int sizeOfSELLSTOCKArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SELLSTOCK$38);
        }
    }
    
    /**
     * Sets array of all "SELLSTOCK" element
     */
    public void setSELLSTOCKArray(net.ofx.types.x2003.x04.SellStock[] sellstockArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(sellstockArray, SELLSTOCK$38);
        }
    }
    
    /**
     * Sets ith "SELLSTOCK" element
     */
    public void setSELLSTOCKArray(int i, net.ofx.types.x2003.x04.SellStock sellstock)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellStock target = null;
            target = (net.ofx.types.x2003.x04.SellStock)get_store().find_element_user(SELLSTOCK$38, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(sellstock);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "SELLSTOCK" element
     */
    public net.ofx.types.x2003.x04.SellStock insertNewSELLSTOCK(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellStock target = null;
            target = (net.ofx.types.x2003.x04.SellStock)get_store().insert_element_user(SELLSTOCK$38, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "SELLSTOCK" element
     */
    public net.ofx.types.x2003.x04.SellStock addNewSELLSTOCK()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.SellStock target = null;
            target = (net.ofx.types.x2003.x04.SellStock)get_store().add_element_user(SELLSTOCK$38);
            return target;
        }
    }
    
    /**
     * Removes the ith "SELLSTOCK" element
     */
    public void removeSELLSTOCK(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SELLSTOCK$38, i);
        }
    }
    
    /**
     * Gets array of all "SPLIT" elements
     */
    public net.ofx.types.x2003.x04.Split[] getSPLITArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SPLIT$40, targetList);
            net.ofx.types.x2003.x04.Split[] result = new net.ofx.types.x2003.x04.Split[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "SPLIT" element
     */
    public net.ofx.types.x2003.x04.Split getSPLITArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Split target = null;
            target = (net.ofx.types.x2003.x04.Split)get_store().find_element_user(SPLIT$40, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "SPLIT" element
     */
    public int sizeOfSPLITArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SPLIT$40);
        }
    }
    
    /**
     * Sets array of all "SPLIT" element
     */
    public void setSPLITArray(net.ofx.types.x2003.x04.Split[] splitArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(splitArray, SPLIT$40);
        }
    }
    
    /**
     * Sets ith "SPLIT" element
     */
    public void setSPLITArray(int i, net.ofx.types.x2003.x04.Split split)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Split target = null;
            target = (net.ofx.types.x2003.x04.Split)get_store().find_element_user(SPLIT$40, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(split);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "SPLIT" element
     */
    public net.ofx.types.x2003.x04.Split insertNewSPLIT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Split target = null;
            target = (net.ofx.types.x2003.x04.Split)get_store().insert_element_user(SPLIT$40, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "SPLIT" element
     */
    public net.ofx.types.x2003.x04.Split addNewSPLIT()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Split target = null;
            target = (net.ofx.types.x2003.x04.Split)get_store().add_element_user(SPLIT$40);
            return target;
        }
    }
    
    /**
     * Removes the ith "SPLIT" element
     */
    public void removeSPLIT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SPLIT$40, i);
        }
    }
    
    /**
     * Gets array of all "TRANSFER" elements
     */
    public net.ofx.types.x2003.x04.Transfer[] getTRANSFERArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(TRANSFER$42, targetList);
            net.ofx.types.x2003.x04.Transfer[] result = new net.ofx.types.x2003.x04.Transfer[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "TRANSFER" element
     */
    public net.ofx.types.x2003.x04.Transfer getTRANSFERArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Transfer target = null;
            target = (net.ofx.types.x2003.x04.Transfer)get_store().find_element_user(TRANSFER$42, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "TRANSFER" element
     */
    public int sizeOfTRANSFERArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TRANSFER$42);
        }
    }
    
    /**
     * Sets array of all "TRANSFER" element
     */
    public void setTRANSFERArray(net.ofx.types.x2003.x04.Transfer[] transferArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(transferArray, TRANSFER$42);
        }
    }
    
    /**
     * Sets ith "TRANSFER" element
     */
    public void setTRANSFERArray(int i, net.ofx.types.x2003.x04.Transfer transfer)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Transfer target = null;
            target = (net.ofx.types.x2003.x04.Transfer)get_store().find_element_user(TRANSFER$42, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(transfer);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "TRANSFER" element
     */
    public net.ofx.types.x2003.x04.Transfer insertNewTRANSFER(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Transfer target = null;
            target = (net.ofx.types.x2003.x04.Transfer)get_store().insert_element_user(TRANSFER$42, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "TRANSFER" element
     */
    public net.ofx.types.x2003.x04.Transfer addNewTRANSFER()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.Transfer target = null;
            target = (net.ofx.types.x2003.x04.Transfer)get_store().add_element_user(TRANSFER$42);
            return target;
        }
    }
    
    /**
     * Removes the ith "TRANSFER" element
     */
    public void removeTRANSFER(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TRANSFER$42, i);
        }
    }
    
    /**
     * Gets array of all "INVBANKTRAN" elements
     */
    public net.ofx.types.x2003.x04.InvestmentBankTransaction[] getINVBANKTRANArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(INVBANKTRAN$44, targetList);
            net.ofx.types.x2003.x04.InvestmentBankTransaction[] result = new net.ofx.types.x2003.x04.InvestmentBankTransaction[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "INVBANKTRAN" element
     */
    public net.ofx.types.x2003.x04.InvestmentBankTransaction getINVBANKTRANArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentBankTransaction target = null;
            target = (net.ofx.types.x2003.x04.InvestmentBankTransaction)get_store().find_element_user(INVBANKTRAN$44, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "INVBANKTRAN" element
     */
    public int sizeOfINVBANKTRANArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INVBANKTRAN$44);
        }
    }
    
    /**
     * Sets array of all "INVBANKTRAN" element
     */
    public void setINVBANKTRANArray(net.ofx.types.x2003.x04.InvestmentBankTransaction[] invbanktranArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(invbanktranArray, INVBANKTRAN$44);
        }
    }
    
    /**
     * Sets ith "INVBANKTRAN" element
     */
    public void setINVBANKTRANArray(int i, net.ofx.types.x2003.x04.InvestmentBankTransaction invbanktran)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentBankTransaction target = null;
            target = (net.ofx.types.x2003.x04.InvestmentBankTransaction)get_store().find_element_user(INVBANKTRAN$44, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(invbanktran);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "INVBANKTRAN" element
     */
    public net.ofx.types.x2003.x04.InvestmentBankTransaction insertNewINVBANKTRAN(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentBankTransaction target = null;
            target = (net.ofx.types.x2003.x04.InvestmentBankTransaction)get_store().insert_element_user(INVBANKTRAN$44, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "INVBANKTRAN" element
     */
    public net.ofx.types.x2003.x04.InvestmentBankTransaction addNewINVBANKTRAN()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.InvestmentBankTransaction target = null;
            target = (net.ofx.types.x2003.x04.InvestmentBankTransaction)get_store().add_element_user(INVBANKTRAN$44);
            return target;
        }
    }
    
    /**
     * Removes the ith "INVBANKTRAN" element
     */
    public void removeINVBANKTRAN(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INVBANKTRAN$44, i);
        }
    }
}
